package com.sunshine.effctive.chapter02.item1;

import java.util.Random;

/**
 * 产生随机的int类型的整数
 *
 * @author WeiHong
 * @date 2019/11/20 19:21
 */
public class RandomIntGenerator {
    private final int min;

    private final int max;

    /**
     * 两个属性min和max被final修饰，所以必须初始化它们，可以在定义它们时就初始化或者通过构造器来初始化。通过构造器初始如下：
     *
     * @param min
     * @param max
     */
    private RandomIntGenerator(int min, int max) {
        this.min = min;
        this.max = max;
    }

    /**
     * 现在，我们要提供给这样一个功能，客户端仅设置一个最小值然后产生一个介于此值和Integer.MAX_VALUE之间的整数。
     * 所以我们添加了第二个构造器：
     *
     * @param min
     */
    private RandomIntGenerator(int min) {
        this.min = min;
        this.max = Integer.MAX_VALUE;
    }

    ///**
    // * 我们同样要提供一个构造器设置一个最大值，然后产生一个介于Integer.MIN_VALUE和最大值的整数。我们添加第三个构造器如下： <br />
    // * 如果你这样做了，将会出现编译错误：Duplicate method RandomIntGenerator(int) in type
    // *
    // * @param max
    // */
    //public RandomIntGenerator(int max) {
    //    this.min = Integer.MIN_VALUE;
    //    this.max = max;
    //}

    /**
     * 像上面这种的情况我们该如何处理呢？幸好有其他方式可以使用：静态工厂方法
     * 将静态工厂应用到RandomIntGenerator类，得到
     * <p>
     * 介于 min 和 max 之间
     *
     * @param min
     * @param max
     * @return
     */
    public static RandomIntGenerator between(int min, int max) {
        return new RandomIntGenerator(min, max);
    }

    /**
     * 介于 min 和 Integer.MAX_VALUE 之间
     *
     * @param min
     * @return
     */
    public static RandomIntGenerator biggerThan(int min) {
        return new RandomIntGenerator(min, Integer.MAX_VALUE);
    }

    /**
     * 介于 Integer.MIN_VALUE 和 max 之间
     *
     * @param max
     * @return
     */
    public static RandomIntGenerator smallerThan(int max) {
        return new RandomIntGenerator(Integer.MIN_VALUE, max);
    }

    public int next() {
        Random random = new Random();
        return random.nextInt(this.max - this.min + 1) + this.min;
    }


}
